#!/bin/bash

# OpenHarmony Build Manager (bl)
# 管理多版本、多分支 OpenHarmony 代码的下载、切换和编译

set -e

# 设置 PATH（确保 cron 环境下也能找到命令）
export PATH="$HOME/bin:$HOME/.bin:$HOME/.local/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:$PATH"

# 加载用户环境变量（用于 crontab 执行）
if [ -f "$HOME/.bashrc" ]; then
    source "$HOME/.bashrc" 2>/dev/null || true
elif [ -f "$HOME/.bash_profile" ]; then
    source "$HOME/.bash_profile" 2>/dev/null || true
elif [ -f "$HOME/.profile" ]; then
    source "$HOME/.profile" 2>/dev/null || true
fi

# 如果是 zsh 用户
if [ -f "$HOME/.zshrc" ] && [ -n "$ZSH_VERSION" ]; then
    source "$HOME/.zshrc" 2>/dev/null || true
fi

# 再次确保关键路径在 PATH 中（防止配置文件覆盖）
export PATH="$HOME/bin:$HOME/.bin:$HOME/.local/bin:$PATH"

# 确保 git 可用（repo 工具依赖）
# repo 可能需要这些环境变量来找到 git
if command -v git >/dev/null 2>&1; then
    export GIT_PYTHON_GIT_EXECUTABLE=$(command -v git)
fi

# 确保 Python 能找到系统库（repo 是 Python 脚本）
export PYTHONIOENCODING=utf-8

# 加载 repo 认证环境变量（优先级从高到低）
# 1. 从专门的环境变量文件加载（推荐，用于敏感信息）
if [ -f "$HOME/.repo_env" ]; then
    source "$HOME/.repo_env" 2>/dev/null || true
fi

# 2. 从 openharmony 目录下的 .env 文件加载
if [ -f "$HOME/openharmony/.env" ]; then
    source "$HOME/openharmony/.env" 2>/dev/null || true
fi

# 调试：显示环境变量状态（仅在调试模式下）
if [ "${BL_DEBUG}" = "1" ]; then
    echo "[DEBUG] ONLINE_USERNAME: ${ONLINE_USERNAME:-未设置}"
    echo "[DEBUG] ONLINE_PASSWD: ${ONLINE_PASSWD:+已设置}"
fi

# 配置
BASE_DIR="$HOME/openharmony"
CODE_DIR="$BASE_DIR/code_download"
WORKSPACE_DIR="$BASE_DIR/workspace"
BRANCHES_CONFIG="$BASE_DIR/.bl_branches"
SETTINGS_FILE="$BASE_DIR/.bl_settings"
MIN_DISK_SPACE_GB=100

# 默认最大版本数
DEFAULT_MAX_VERSIONS=2

# 默认定时下载开关（1=启用，0=禁用）
DEFAULT_CRON_ENABLED=1

# 加载设置
load_settings() {
    MAX_VERSIONS=$DEFAULT_MAX_VERSIONS
    CRON_ENABLED=$DEFAULT_CRON_ENABLED
    if [ -f "$SETTINGS_FILE" ]; then
        source "$SETTINGS_FILE" 2>/dev/null || true
    fi
}

# 保存设置
save_settings() {
    cat > "$SETTINGS_FILE" << EOF
# bl 设置文件
MAX_VERSIONS=$MAX_VERSIONS
CRON_ENABLED=$CRON_ENABLED
EOF
}

# 设置最大版本数
set_max_versions() {
    local num=$1

    if [ -z "$num" ]; then
        echo ""
        print_info "当前最大保留版本数: $MAX_VERSIONS"
        echo ""
        read -p "请输入新的最大保留版本数 [1-10]: " num
    fi

    if [ -z "$num" ]; then
        print_info "已取消"
        return 0
    fi

    if ! [[ "$num" =~ ^[0-9]+$ ]] || [ "$num" -lt 1 ] || [ "$num" -gt 10 ]; then
        print_error "无效的数量，请输入 1-10 之间的数字"
        return 1
    fi

    MAX_VERSIONS=$num
    save_settings
    print_success "已设置最大保留版本数为: $MAX_VERSIONS"
}

# 启用定时下载
enable_cron() {
    CRON_ENABLED=1
    save_settings
    print_success "已启用定时下载"
    print_info "定时任务将正常执行下载和编译"
}

# 禁用定时下载
disable_cron() {
    CRON_ENABLED=0
    save_settings
    print_success "已禁用定时下载"
    print_info "定时任务将跳过执行（crontab 条目保留，但任务不会执行）"
}

# 显示定时下载状态
show_cron_status() {
    echo ""
    if [ "$CRON_ENABLED" = "1" ]; then
        print_info "定时下载状态: ${GREEN}已启用${NC}"
    else
        print_info "定时下载状态: ${YELLOW}已禁用${NC}"
    fi
    echo ""
    print_info "使用 'bl cron-enable' 启用定时下载"
    print_info "使用 'bl cron-disable' 禁用定时下载"
}

# 加载设置
load_settings

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

# 打印带颜色的消息
print_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

print_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

print_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

print_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# 初始化目录结构
init_dirs() {
    mkdir -p "$CODE_DIR"
    mkdir -p "$WORKSPACE_DIR"

    # 如果分支配置不存在，说明是首次运行（通常由 install.sh 创建）
    if [ ! -f "$BRANCHES_CONFIG" ]; then
        echo "# OpenHarmony Branches Configuration" > "$BRANCHES_CONFIG"
        print_warning "分支配置为空，请运行 './install.sh' 初始化"
    fi
}

# 检查磁盘空间
check_disk_space() {
    local available_gb=$(df -BG "$CODE_DIR" | awk 'NR==2 {print $4}' | sed 's/G//')
    
    if [ "$available_gb" -lt "$MIN_DISK_SPACE_GB" ]; then
        print_error "磁盘空间不足！"
        print_error "可用空间: ${available_gb}GB"
        print_error "需要空间: ${MIN_DISK_SPACE_GB}GB"
        return 1
    fi
    
    print_info "磁盘可用空间: ${available_gb}GB"
    return 0
}

# 分支名转义（用于变量名）
sanitize_branch_name() {
    echo "$1" | sed 's/[^a-zA-Z0-9_]/_/g'
}

# 添加分支配置
add_branch_config() {
    local name=$1
    local repo_cmd=$2
    local prebuilts_cmd=$3
    local build_cmd=$4
    local silent=${5:-false}
    
    # 检查分支是否已存在
    if grep -q "^# Branch: ${name}$" "$BRANCHES_CONFIG" 2>/dev/null; then
        $silent || print_warning "分支 '$name' 已存在"
        return 1
    fi
    
    local safe_name=$(sanitize_branch_name "$name")
    
    cat >> "$BRANCHES_CONFIG" << EOF

# Branch: $name
BRANCH_${safe_name}_REPO_CMD="$repo_cmd"
BRANCH_${safe_name}_PREBUILTS_CMD="$prebuilts_cmd"
BRANCH_${safe_name}_BUILD_CMD="$build_cmd"
EOF
    
    $silent || print_success "已添加分支配置: $name"
}

# 删除分支配置
remove_branch_config() {
    local name=$1
    
    if [ "$name" = "trunk" ]; then
        print_error "不能删除 trunk 分支"
        return 1
    fi

    if ! grep -q "^# Branch: ${name}$" "$BRANCHES_CONFIG" 2>/dev/null; then
        print_error "分支 '$name' 不存在"
        return 1
    fi

    local safe_name=$(sanitize_branch_name "$name")

    sed -i "/^# Branch: ${name}$/,/^BRANCH_${safe_name}_BUILD_CMD=/d" "$BRANCHES_CONFIG"

    print_success "已删除分支配置: $name"
}

# 列出所有分支
list_branches() {
    if [ ! -f "$BRANCHES_CONFIG" ]; then
        echo "trunk"
        return
    fi
    
    grep "^# Branch:" "$BRANCHES_CONFIG" | sed 's/# Branch: //' || echo "trunk"
}

# 加载指定分支配置
load_branch_config() {
    local branch_name=$1

    if [ -z "$branch_name" ]; then
        print_error "未指定分支名"
        return 1
    fi

    if [ ! -f "$BRANCHES_CONFIG" ]; then
        init_dirs
    fi

    source "$BRANCHES_CONFIG"

    local safe_name=$(sanitize_branch_name "$branch_name")

    # 动态获取分支配置
    local var_prefix="BRANCH_${safe_name}_"
    REPO_CMD=$(eval echo "\$${var_prefix}REPO_CMD")
    PREBUILTS_CMD=$(eval echo "\$${var_prefix}PREBUILTS_CMD")
    BUILD_CMD=$(eval echo "\$${var_prefix}BUILD_CMD")

    # 清理可能的空格
    REPO_CMD=$(echo "$REPO_CMD" | xargs)
    PREBUILTS_CMD=$(echo "$PREBUILTS_CMD" | xargs)
    BUILD_CMD=$(echo "$BUILD_CMD" | xargs)

    # 如果配置为空，使用默认值
    REPO_CMD=${REPO_CMD:-"repo init -u https://gitcode.com/openharmony/manifest.git -b master --no-repo-verify"}
    PREBUILTS_CMD=${PREBUILTS_CMD:-"bash build/prebuilts_download.sh"}
    BUILD_CMD=${BUILD_CMD:-"./build.sh --product-name rk3568 --ccache --build-target graphic_2d"}
}

# 更新分支配置
update_branch_config() {
    local name=$1
    local repo_cmd=$2
    local prebuilts_cmd=$3
    local build_cmd=$4
    
    local safe_name=$(sanitize_branch_name "$name")
    
    sed -i "/^# Branch: ${name}$/,/^BRANCH_${safe_name}_BUILD_CMD=/d" "$BRANCHES_CONFIG"
    add_branch_config "$name" "$repo_cmd" "$prebuilts_cmd" "$build_cmd" true
}

# 显示帮助信息
show_help() {
    cat << EOF
OpenHarmony Build Manager (bl) - 管理多版本、多分支 OpenHarmony 代码

用法:
    bl                  显示当前状态
    bl <分支名>         一键下载并编译指定分支代码（自动化，无交互）

命令:
    --help, -h          显示此帮助信息
    status, -s          显示当前状态
    list, -l            列出并选择版本添加到工作目录（自动保护）
    download <分支名>   下载指定分支的新版本代码
    build <版本号>      编译指定版本代码
    clean [分支名]      清理旧版本（保留最新 ${MAX_VERSIONS} 个，工作目录中的版本跳过）
    remove <版本号>     彻底删除指定版本（代码+工作区链接）
    config              配置分支参数
    show-config         显示分支配置
    set-max <数量>      设置最大保留版本数（当前: ${MAX_VERSIONS}）

定时下载控制:
    cron-enable         启用定时下载
    cron-disable        禁用定时下载（crontab 条目保留，但任务不执行）
    cron-status         显示定时下载状态

分支管理:
    branch list         列出所有分支
    branch add          添加新分支
    branch remove       删除分支
    branch config       配置分支参数
    branch show         显示分支配置

示例:
    bl                              # 查看状态
    bl trunk                        # 一键下载并编译 trunk
    bl download trunk               # 仅下载 trunk 分支代码
    bl list                         # 选择版本添加到工作目录
    bl build trunk_20251103_000132  # 编译指定版本
    bl clean                        # 清理所有分支的旧版本
    bl clean trunk                  # 仅清理 trunk 分支的旧版本
    bl remove trunk_20251103_000132 # 彻底删除指定版本
    bl set-max 3                    # 设置最大保留 3 个版本
    bl cron-disable                 # 禁用定时下载
    bl cron-enable                  # 启用定时下载
    bl cron-status                  # 查看定时下载状态

目录结构:
    ~/openharmony/
    ├── code_download/              # 代码存储（自动管理）
    │   ├── trunk_20251103_000132/
    │   └── dev_20251105_120000/
    └── workspace/                  # 工作目录（符号链接）
        ├── trunk_20251103_000132/  -> ../code_download/trunk_20251103_000132
        └── dev_20251105_120000/    -> ../code_download/dev_20251105_120000

版本保护机制:
    • 使用 'bl list' 添加到工作目录的版本自动受保护（🛡）
    • 工作目录中的版本在 'bl clean' 时会被跳过
    • 删除工作目录链接后，保护自动失效:
      rm ~/openharmony/workspace/trunk_20251103_000132
    • 彻底删除版本（代码+链接）:
      bl remove trunk_20251103_000132

EOF
}

# 获取版本号（分支名_日期_时间）
get_version() {
    local branch_name=$1
    echo "${branch_name}_$(date +%Y%m%d_%H%M%S)"
}

# 列出所有已下载的版本
list_versions() {
    local branch_filter=${1:-}

    if [ ! -d "$CODE_DIR" ] || [ -z "$(ls -A "$CODE_DIR" 2>/dev/null)" ]; then
        print_warning "没有找到已下载的代码版本"
        return 1
    fi

    for dir in "$CODE_DIR"/*; do
        if [ -d "$dir" ]; then
            local dirname=$(basename "$dir")
            # 新格式: branch_YYYYMMDD_HHMMSS
            if [[ "$dirname" =~ ^.+_[0-9]{8}_[0-9]{6}$ ]]; then
                if [ -n "$branch_filter" ]; then
                    # 提取分支名（去掉最后的 _YYYYMMDD_HHMMSS）
                    local branch_name=$(echo "$dirname" | sed 's/_[0-9]\{8\}_[0-9]\{6\}$//')
                    if [ "$branch_name" = "$branch_filter" ]; then
                        echo "$dirname"
                    fi
                else
                    echo "$dirname"
                fi
            fi
        fi
    done | sort -r
}

# 获取指定版本的工作目录路径（版本格式：分支名_日期_时间）
get_workspace_link_path() {
    local version=$1
    # 版本格式已经是：trunk_20251103_000132，直接用作工作目录链接名
    echo "$WORKSPACE_DIR/${version}"
}


# 获取分支的定时任务时间
get_cron_time() {
    local branch=$1
    local cron_line=$(crontab -l 2>/dev/null | grep "bl $branch " | head -1)
    if [ -n "$cron_line" ]; then
        # 提取分钟和小时
        local minute=$(echo "$cron_line" | awk '{print $1}')
        local hour=$(echo "$cron_line" | awk '{print $2}')
        printf "%02d:%02d" "$hour" "$minute"
    else
        echo ""
    fi
}

# 显示状态
show_status() {
    echo ""
    print_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    print_info "        OpenHarmony 代码管理状态"
    print_info "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    echo ""

    # 显示全局设置
    echo -e "${BLUE}┌─ 全局设置${NC}"
    echo -e "${BLUE}│${NC}  最大保留版本数: ${CYAN}${MAX_VERSIONS}${NC}"
    if [ "$CRON_ENABLED" = "1" ]; then
        echo -e "${BLUE}│${NC}  定时下载: ${GREEN}已启用${NC}"
    else
        echo -e "${BLUE}│${NC}  定时下载: ${YELLOW}已禁用${NC}"
    fi
    echo -e "${BLUE}└─${NC}"
    echo ""

    # 自动清理失效的工作目录链接
    cleanup_broken_workspace_links

    # 显示所有分支的状态
    local all_branches=($(list_branches))

    if [ ${#all_branches[@]} -eq 0 ]; then
        print_warning "暂无分支，请先使用 'bl branch add' 添加分支"
        return
    fi

    for branch in "${all_branches[@]}"; do
        # 获取定时任务时间
        local cron_time=$(get_cron_time "$branch")
        local cron_info=""
        if [ -n "$cron_time" ]; then
            cron_info=" ${YELLOW}[定时: ${cron_time}]${NC}"
        fi

        echo -e "${BLUE}┌─ 分支:${NC} ${CYAN}${branch}${NC}${cron_info}"

        # 获取该分支的版本列表（只调用一次）
        local versions=($(list_versions "$branch" 2>/dev/null))
        local count=${#versions[@]}

        if [ $count -gt 0 ]; then
            echo -e "${BLUE}└─${NC} 已下载版本 (${count} 个):"

            for version in "${versions[@]}"; do
                # 检查是否在工作目录
                local workspace_link=$(get_workspace_link_path "$version")
                local in_workspace=""
                if [ -L "$workspace_link" ]; then
                    in_workspace=" ${CYAN}[工作区]${NC}"
                fi

                # 检查是否受保护
                local protected_mark=""
                if is_version_protected "$version"; then
                    protected_mark=" ${GREEN}🛡${NC}"
                fi

                echo -e "   ${BLUE}•${NC} $version${in_workspace}${protected_mark}"
            done
        else
            echo -e "${BLUE}└─${NC} ${YELLOW}暂无已下载的版本${NC}"
        fi

        echo ""
    done

    check_disk_space
    echo ""
}

# 交互式选择版本
interactive_select() {
    echo ""
    print_info "=== 选择代码版本到工作目录（所有分支）==="
    echo ""
    
    # 收集所有分支的所有版本
    local all_branches=($(list_branches))
    local all_versions=()
    local version_branches=()
    
    for branch in "${all_branches[@]}"; do
        local branch_versions=($(list_versions "$branch" 2>/dev/null))
        for version in "${branch_versions[@]}"; do
            all_versions+=("$version")
            version_branches+=("$branch")
        done
    done
    
    if [ ${#all_versions[@]} -eq 0 ]; then
        print_error "没有可用的代码版本，请先使用 'bl download' 下载代码"
        return 1
    fi
    
    # 显示所有版本
    local i=1
    for idx in "${!all_versions[@]}"; do
        local version="${all_versions[$idx]}"
        local branch="${version_branches[$idx]}"
        
        # 检查是否已在工作目录
        local workspace_link=$(get_workspace_link_path "$version")
        local in_workspace=""
        if [ -L "$workspace_link" ]; then
            in_workspace=" ${CYAN}[已在工作区]${NC}"
        fi
        
        # 检查是否受保护
        local protected_mark=""
        if is_version_protected "$version"; then
            protected_mark=" ${GREEN}🛡${NC}"
        fi
        
        echo -e "  [$i] $version${in_workspace}${protected_mark}"
        i=$((i + 1))
    done
    
    echo ""
    read -p "请选择版本 [1-${#all_versions[@]}] (回车取消): " choice
    
    if [ -z "$choice" ]; then
        print_info "已取消"
        return 0
    fi
    
    if ! [[ "$choice" =~ ^[0-9]+$ ]] || [ "$choice" -lt 1 ] || [ "$choice" -gt ${#all_versions[@]} ]; then
        print_error "无效的选择"
        return 1
    fi
    
    local selected_version="${all_versions[$((choice - 1))]}"
    switch_version "$selected_version"
}

# 切换版本（添加到工作目录即自动保护）
switch_version() {
    local version=$1
    local version_path="$CODE_DIR/$version"

    if [ ! -d "$version_path" ]; then
        print_error "版本 $version 不存在"
        return 1
    fi

    # 获取工作目录链接路径
    local workspace_link=$(get_workspace_link_path "$version")

    # 如果链接还不存在，创建它
    if [ ! -L "$workspace_link" ]; then
        ln -s "../code_download/$version" "$workspace_link"
        print_success "✓ 已添加版本到工作目录（自动保护）"
        print_info "  路径: $workspace_link"
    else
        print_info "版本已在工作目录中: $workspace_link"
    fi
}

# 下载代码
download_code() {
    init_dirs
    local target_branch=$1
    
    # 检查是否提供了分支参数
    if [ -z "$target_branch" ]; then
        print_error "请指定要下载的分支名"
        echo ""
        print_info "用法: bl download <分支名>"
        echo ""
        print_info "可用分支:"
        list_branches | sed 's/^/  /'
        return 1
    fi
    
    # 验证分支是否存在
    if ! list_branches | grep -q "^${target_branch}$"; then
        print_error "分支 '$target_branch' 不存在"
        echo ""
        print_info "可用分支:"
        list_branches | sed 's/^/  /'
        return 1
    fi
    
    load_branch_config "$target_branch"
    
    # 确保在安全的工作目录
    cd "$BASE_DIR" || cd "$HOME"
    
    # 检查磁盘空间
    if ! check_disk_space; then
        return 1
    fi
    
    # 检查版本数量，自动清理旧版本（为新版本腾出空间）
    local version_count=$(list_versions "$target_branch" 2>/dev/null | wc -l)
    if [ "$version_count" -ge "$MAX_VERSIONS" ]; then
        print_warning "分支 $target_branch 已达到最大版本数量 ($MAX_VERSIONS)"
        print_info "正在自动清理该分支的旧版本，为新版本腾出空间..."
        clean_old_versions "$target_branch" "true"
    fi
    
    local version=$(get_version "$target_branch")
    local download_path="$CODE_DIR/$version"
    
    print_info "=== 开始下载 OpenHarmony 代码 ==="
    print_info "分支配置: $target_branch"
    print_info "版本: $version"
    print_info "下载路径: $download_path"
    echo ""
    
    mkdir -p "$download_path"
    cd "$download_path" || {
        print_error "无法进入下载目录: $download_path"
        return 1
    }
    
    # 执行 repo init 命令（完整命令）
    print_info "步骤 1/3: 执行 repo 初始化..."
    print_info "命令: $REPO_CMD"
    
    # 检查 repo 命令是否存在
    if ! command -v repo &> /dev/null; then
        print_error "repo 命令未找到"
        print_error "请确保 repo 已安装并在 PATH 中"
        print_error "当前 PATH: $PATH"
        print_error ""
        print_error "安装 repo:"
        print_error "  mkdir -p ~/.bin"
        print_error "  curl https://storage.googleapis.com/git-repo-downloads/repo > ~/.bin/repo"
        print_error "  chmod a+x ~/.bin/repo"
        print_error "  export PATH=~/.bin:\$PATH"
        cd "$BASE_DIR" || cd "$HOME"
        rm -rf "$download_path"
        return 1
    fi
    
    if ! eval "$REPO_CMD"; then
        print_error "repo 初始化失败"
        print_error "请检查命令: $REPO_CMD"
        cd "$BASE_DIR" || cd "$HOME"
        rm -rf "$download_path"
        return 1
    fi
    
    # 同步代码
    print_info "步骤 2/3: 同步代码..."
    if ! repo sync -c --no-tags -j96; then
        print_error "代码同步失败"
        cd "$BASE_DIR" || cd "$HOME"
        rm -rf "$download_path"
        return 1
    fi
    
    # 下载预编译文件
    print_info "步骤 3/3: 下载预编译文件..."
    print_info "命令: $PREBUILTS_CMD"
    if ! eval "$PREBUILTS_CMD"; then
        print_error "预编译文件下载失败"
        cd "$BASE_DIR" || cd "$HOME"
        rm -rf "$download_path"
        return 1
    fi
    
    # 返回到安全目录
    cd "$BASE_DIR" || cd "$HOME"
    
    print_success "代码下载完成: $version"
    
    return 0
}

# 编译指定版本的代码
build_version() {
    local version_path=$1
    local version=$(basename "$version_path")

    # 从版本号中提取分支名（新格式：branch_name_20241027_120000）
    local branch_name=$(echo "$version" | sed 's/_[0-9]\{8\}_[0-9]\{6\}$//')
    load_branch_config "$branch_name"
    
    print_info "=== 编译 OpenHarmony ==="
    print_info "分支: $branch_name"
    print_info "版本: $version"
    print_info "编译命令: $BUILD_CMD"
    echo ""
    
    cd "$version_path" || {
        print_error "无法进入目录: $version_path"
        return 1
    }
    
    print_info "开始编译..."
    if eval "$BUILD_CMD"; then
        print_success "编译完成"
        print_info "输出目录: $version_path/out"
        cd "$BASE_DIR" || cd "$HOME"
        return 0
    else
        print_error "编译失败"
        cd "$BASE_DIR" || cd "$HOME"
        return 1
    fi
}

# 编译代码
build_code() {
    local version=$1
    
    # 检查是否提供了版本参数
    if [ -z "$version" ]; then
        print_error "请指定要编译的版本号"
        echo ""
        print_info "用法: bl build <版本号>"
        echo ""
        print_info "可用版本（最新10个）:"
        ls -1t "$CODE_DIR" 2>/dev/null | head -10 | sed 's/^/  /'
        return 1
    fi
    
    # 检查版本是否存在
    local version_path="$CODE_DIR/$version"
    if [ ! -d "$version_path" ]; then
        print_error "版本 '$version' 不存在"
        echo ""
        print_info "可用版本（最新10个）:"
        ls -1t "$CODE_DIR" 2>/dev/null | head -10 | sed 's/^/  /'
        return 1
    fi
    
    build_version "$version_path"
}

# 清理旧版本（针对指定分支或所有分支）
# 参数: $1=分支名(可选), $2=是否为新版本腾空间(可选, "true"时会多删一个)
clean_old_versions() {
    local target_branch=$1
    local make_room=${2:-false}

    # 切换到安全目录，避免在被删除的目录中操作
    cd "$BASE_DIR" || cd "$HOME"

    # 先清理失效的工作目录链接
    cleanup_broken_workspace_links

    # 如果指定了分支，只清理该分支
    if [ -n "$target_branch" ]; then
        clean_branch_versions "$target_branch" "$make_room"
    else
        # 否则清理所有分支
        print_info "开始清理所有分支的旧版本..."
        echo ""
        while IFS= read -r branch; do
            clean_branch_versions "$branch" "$make_room"
            echo ""
        done < <(list_branches)
    fi
}

# 清理指定分支的旧版本
# 参数: $1=分支名, $2=是否为新版本腾空间(可选, "true"时会多删一个)
clean_branch_versions() {
    local branch=$1
    local make_room=${2:-false}
    local versions=($(list_versions "$branch"))

    # 计算保留数量：如果是为新版本腾空间，需要少保留一个
    local keep_count=$MAX_VERSIONS
    if [ "$make_room" = "true" ]; then
        keep_count=$((MAX_VERSIONS - 1))
    fi

    if [ ${#versions[@]} -le "$keep_count" ]; then
        print_info "分支 $branch: 版本数量 ${#versions[@]}，无需清理"
        return 0
    fi

    print_info "分支 $branch: 保留最新 $keep_count 个版本，清理旧版本..."

    local removed=0
    local to_remove=$((${#versions[@]} - keep_count))
    
    # 从最旧的版本开始删除
    for ((i=${#versions[@]}-1; i>=0 && removed<$to_remove; i--)); do
        local version="${versions[$i]}"
        
        # 跳过受保护的版本
        if is_version_protected "$version"; then
            echo -e "  跳过受保护版本: ${GREEN}🛡${NC} $version"
            continue
        fi
        
        # 删除版本
        local version_path="$CODE_DIR/$version"
        print_info "  删除版本: $version"
        # 确保不在要删除的目录中
        if [[ "$PWD" == "$version_path"* ]]; then
            cd "$BASE_DIR" || cd "$HOME"
        fi
        
        # 删除代码目录
        rm -rf "$version_path"

        # 删除工作目录链接（如果存在）
        local workspace_link=$(get_workspace_link_path "$version")
        if [ -L "$workspace_link" ]; then
            rm -f "$workspace_link"
            print_info "  同时删除工作区链接: $(basename "$workspace_link")"
        fi

        removed=$((removed + 1))
    done
    
    print_success "分支 $branch: 清理完成，已删除 $removed 个旧版本"
}

# 删除指定版本
remove_version() {
    local version=$1
    
    if [ -z "$version" ]; then
        print_error "请指定要删除的版本"
        return 1
    fi
    
    local version_path="$CODE_DIR/$version"
    
    if [ ! -d "$version_path" ]; then
        print_error "版本 $version 不存在"
        return 1
    fi
    
    # 检查是否受保护（在工作目录中）
    if is_version_protected "$version"; then
        print_warning "版本 $version 在工作目录中（受保护）"
        read -r -p "是否同时删除工作区链接? [y/N]: " remove_link
        if [ "$remove_link" != "y" ] && [ "$remove_link" != "Y" ]; then
            print_info "已取消"
            return 0
        fi
    fi

    read -r -p "确认删除版本 $version? [y/N]: " confirm
    if [ "$confirm" = "y" ] || [ "$confirm" = "Y" ]; then
        print_info "删除版本: $version"

        # 如果当前在要删除的目录中，先切换到安全目录
        if [[ "$PWD" == "$version_path"* ]]; then
            cd "$BASE_DIR" || cd "$HOME"
        fi

        # 删除工作目录链接（如果存在）
        local workspace_link=$(get_workspace_link_path "$version")
        if [ -L "$workspace_link" ]; then
            rm -f "$workspace_link"
            print_info "已删除工作区链接: $(basename "$workspace_link")"
        fi

        # 删除代码目录
        rm -rf "$version_path"

        print_success "版本已删除"
    else
        print_info "已取消"
    fi
}

# ========================================
# 受保护版本管理（基于工作目录链接）
# ========================================

# 检查版本是否受保护（在工作目录中即受保护）
is_version_protected() {
    local version=$1
    local workspace_link=$(get_workspace_link_path "$version")
    # 检查工作目录链接是否存在
    [ -L "$workspace_link" ]
}

# 清理无效的工作目录链接（目标不存在的断链）
cleanup_broken_workspace_links() {
    local cleaned=0
    if [ -d "$WORKSPACE_DIR" ]; then
        for link in "$WORKSPACE_DIR"/*; do
            if [ -L "$link" ] && [ ! -e "$link" ]; then
                local link_name=$(basename "$link")
                rm -f "$link"
                print_info "清理失效链接: $link_name"
                cleaned=$((cleaned + 1))
            fi
        done
    fi
    if [ $cleaned -gt 0 ]; then
        print_success "已清理 $cleaned 个失效的工作目录链接"
        echo ""
    fi
}

# 分支管理命令
branch_command() {
    local subcmd=${1:-list}
    shift || true

    case "$subcmd" in
        list)
            branch_list
            ;;
        add)
            branch_add
            ;;
        remove)
            branch_remove
            ;;
        config)
            branch_config
            ;;
        show)
            branch_show
            ;;
        *)
            print_error "未知分支命令: $subcmd"
            echo ""
            echo "可用命令: list, add, remove, config, show"
            return 1
            ;;
    esac
}

# 列出所有分支
branch_list() {
    echo ""
    print_info "=== 分支列表 ==="
    echo ""

    while IFS= read -r branch; do
        echo "  • $branch"
    done < <(list_branches)
    echo ""
}

# 添加分支
branch_add() {
    echo ""
    print_info "=== 添加新分支配置 ==="
    echo ""
    
    read -p "分支名称 (用于目录和版本标识，例如: dev, 3.2-Release): " name
    if [ -z "$name" ]; then
        print_error "分支名称不能为空"
        return 1
    fi
    
    if [[ ! "$name" =~ ^[a-zA-Z0-9._-]+$ ]]; then
        print_error "分支名称只能包含字母、数字、点、下划线和连字符"
        return 1
    fi
    
    # 默认值
    local default_repo_cmd="repo init -u https://gitcode.com/openharmony/manifest.git -b master --no-repo-verify"
    local default_prebuilts_cmd="bash build/prebuilts_download.sh"
    local default_build_cmd="./build.sh --product-name rk3568 --ccache --build-target graphic_2d"
    
    echo ""
    print_info "配置 Repo 下载命令:"
    echo "直接输入完整的 repo init 命令，或使用默认值"
    echo ""
    
    read -p "Repo 命令 [$default_repo_cmd]: " repo_cmd
    repo_cmd=${repo_cmd:-$default_repo_cmd}
    
    echo ""
    read -p "预编译命令 [$default_prebuilts_cmd]: " prebuilts_cmd
    prebuilts_cmd=${prebuilts_cmd:-$default_prebuilts_cmd}
    
    echo ""
    read -p "编译命令 [$default_build_cmd]: " build_cmd
    build_cmd=${build_cmd:-$default_build_cmd}
    
    echo ""
    print_info "=== 配置预览 ==="
    echo "  分支名称:   $name"
    echo "  Repo 命令:  $repo_cmd"
    echo "  预编译:     $prebuilts_cmd"
    echo "  编译:       $build_cmd"
    echo ""
    
    read -p "确认添加? [Y/n]: " confirm
    if [ "$confirm" = "n" ] || [ "$confirm" = "N" ]; then
        print_info "已取消"
        return 0
    fi

    add_branch_config "$name" "$repo_cmd" "$prebuilts_cmd" "$build_cmd"
}

# 删除分支
branch_remove() {
    branch_list

    read -p "请输入要删除的分支名称: " name
    if [ -z "$name" ]; then
        print_info "已取消"
        return 0
    fi

    remove_branch_config "$name"
}

# 配置分支（交互式选择分支）
branch_config() {
    local branches=($(list_branches))

    if [ ${#branches[@]} -eq 0 ]; then
        print_warning "暂无分支配置"
        return 1
    fi

    echo ""
    print_info "=== 选择要配置的分支 ==="
    echo ""

    local i=1
    for branch in "${branches[@]}"; do
        echo "  [$i] $branch"
        i=$((i + 1))
    done

    echo ""
    read -p "请选择分支 [1-${#branches[@]}] (回车取消): " choice

    if [ -z "$choice" ]; then
        print_info "已取消"
        return 0
    fi

    if ! [[ "$choice" =~ ^[0-9]+$ ]] || [ "$choice" -lt 1 ] || [ "$choice" -gt ${#branches[@]} ]; then
        print_error "无效的选择"
        return 1
    fi

    local selected_branch="${branches[$((choice - 1))]}"
    _branch_config_edit "$selected_branch"
}

# 编辑分支配置
_branch_config_edit() {
    local branch_name=$1
    load_branch_config "$branch_name"

    echo ""
    print_info "=== 配置分支: $branch_name ==="
    echo ""
    echo "当前配置:"
    echo "  [1] Repo 命令:      $REPO_CMD"
    echo "  [2] 预编译命令:     $PREBUILTS_CMD"
    echo "  [3] 编译命令:       $BUILD_CMD"
    echo "  [0] 保存并退出"
    echo ""
    
    local new_repo_cmd="$REPO_CMD"
    local new_prebuilts_cmd="$PREBUILTS_CMD"
    local new_build_cmd="$BUILD_CMD"
    
    while true; do
        read -p "选择要修改的项 [0-3]: " choice
        
        case $choice in
            1)
                echo "输入完整的 repo init 命令"
                read -p "Repo 命令 [$new_repo_cmd]: " input
                [ -n "$input" ] && new_repo_cmd="$input"
                ;;
            2)
                read -p "预编译命令 [$new_prebuilts_cmd]: " input
                [ -n "$input" ] && new_prebuilts_cmd="$input"
                ;;
            3)
                read -p "编译命令 [$new_build_cmd]: " input
                [ -n "$input" ] && new_build_cmd="$input"
                ;;
            0)
                update_branch_config "$branch_name" "$new_repo_cmd" "$new_prebuilts_cmd" "$new_build_cmd"
                print_success "配置已保存"
                return 0
                ;;
            *)
                print_error "无效选择"
                ;;
        esac
        
        echo ""
        echo "已更新配置，继续修改或选择 0 保存退出"
        echo ""
    done
}

# 显示分支配置（显示所有分支或指定分支）
branch_show() {
    local target_branch=$1

    echo ""

    if [ -n "$target_branch" ]; then
        # 显示指定分支的配置
        if ! list_branches | grep -q "^${target_branch}$"; then
            print_error "分支 '$target_branch' 不存在"
            return 1
        fi

        load_branch_config "$target_branch"
        print_info "=== 分支配置: $target_branch ==="
        echo ""
        echo "  Repo 命令:      $REPO_CMD"
        echo "  预编译命令:     $PREBUILTS_CMD"
        echo "  编译命令:       $BUILD_CMD"
    else
        # 显示所有分支的配置
        print_info "=== 所有分支配置 ==="
        echo ""

        while IFS= read -r branch; do
            load_branch_config "$branch"
            echo -e "${CYAN}[$branch]${NC}"
            echo "  Repo 命令:      $REPO_CMD"
            echo "  预编译命令:     $PREBUILTS_CMD"
            echo "  编译命令:       $BUILD_CMD"
            echo ""
        done < <(list_branches)
    fi

    print_info "配置文件位置:"
    echo "  分支配置: $BRANCHES_CONFIG"
    echo ""
    echo "编辑配置: bl config"
}

# 清理旧日志（只保留当天的）
cleanup_old_logs() {
    local log_file=$1
    
    if [ ! -f "$log_file" ]; then
        return
    fi
    
    # 获取日志文件的修改日期（格式：YYYYMMDD）
    local log_date=$(date -r "$log_file" +%Y%m%d 2>/dev/null || stat -c %y "$log_file" | cut -d' ' -f1 | tr -d '-')
    # 获取今天的日期（格式：YYYYMMDD）
    local today=$(date +%Y%m%d)
    
    # 如果日志不是今天的，清空它
    if [ "$log_date" != "$today" ]; then
        echo "=== 新的一天，清理旧日志 ===" > "$log_file"
        echo "日期: $(date '+%Y-%m-%d %H:%M:%S')" >> "$log_file"
        echo "" >> "$log_file"
    fi
}

# 一键下载并编译（自动化，无交互）
quick_build() {
    local target_branch=$1
    local force=${2:-false}  # 是否强制执行（忽略 CRON_ENABLED 设置）

    # 清理旧日志（只保留当天的）
    local log_file="$BASE_DIR/cron_${target_branch}.log"
    cleanup_old_logs "$log_file"

    # 检查定时下载开关（仅当从 cron 调用且非强制模式时）
    if [ "$BL_CRON_MODE" = "1" ] && [ "$force" != "true" ] && [ "$CRON_ENABLED" != "1" ]; then
        print_warning "定时下载已禁用，跳过执行"
        print_info "使用 'bl cron-enable' 启用定时下载"
        print_info "或使用 'bl $target_branch' 手动执行"
        return 0
    fi

    if ! list_branches | grep -q "^${target_branch}$"; then
        print_error "分支 '$target_branch' 不存在"
        echo ""
        print_info "可用分支:"
        list_branches | sed 's/^/  /'
        echo ""
        print_info "使用 'bl branch add' 添加新分支"
        return 1
    fi
    
    print_info "=== 自动构建: $target_branch ==="
    echo ""
    
    # 下载代码（直接传递分支参数）
    print_info "步骤 1/2: 下载代码..."
    echo ""
    if ! download_code "$target_branch"; then
        print_error "代码下载失败"
        return 1
    fi
    
    # 获取最新下载的版本
    local latest_version=$(list_versions "$target_branch" | head -n 1)
    local latest_version_path="$CODE_DIR/$latest_version"
    
    echo ""
    # 编译代码（不激活到工作目录）
    print_info "步骤 2/2: 编译代码..."
    echo ""
    
    if ! build_version "$latest_version_path"; then
        print_error "编译失败"
        return 1
    fi
    
    echo ""
    print_success "=== 自动构建完成！==="
    print_info "分支: $target_branch"
    print_info "版本: $latest_version"
    print_info "路径: $latest_version_path"
    echo ""
    print_info "工作目录未改变，使用 'bl list' 手动切换版本"
}

# 主函数
main() {
    init_dirs

    # 定义保留关键字
    local reserved_commands="help list download build clean status branch remove config show-config set-max cron-enable cron-disable cron-status"

    case "${1:-}" in
        --help|-h|help)
            show_help
            ;;
        list|-l)
            interactive_select
            ;;
        download|-d)
            download_code "$2"
            ;;
        build|-b)
            build_code "$2"
            ;;
        clean)
            clean_old_versions "$2"  # $2 可以是分支名，不传则清理所有分支
            ;;
        status|-s)
            show_status
            ;;
        config|-c)
            branch_config
            ;;
        show-config)
            branch_show
            ;;
        branch)
            shift
            branch_command "$@"
            ;;
        remove)
            remove_version "$2"
            ;;
        set-max)
            set_max_versions "$2"
            ;;
        cron-enable)
            enable_cron
            ;;
        cron-disable)
            disable_cron
            ;;
        cron-status)
            show_cron_status
            ;;
        "")
            show_status
            echo ""
            print_info "使用 'bl --help' 查看帮助信息"
            ;;
        *)
            # 检查是否是保留命令
            if echo "$reserved_commands" | grep -qw "${1}"; then
                print_error "未知命令: $1"
                echo ""
                show_help
                exit 1
            # 检查是否是分支名（一键构建）
            elif list_branches | grep -q "^${1}$"; then
                quick_build "$1"
            else
                print_error "未知命令或分支: $1"
                echo ""
                print_info "可用分支:"
                list_branches | sed 's/^/  /'
                echo ""
                print_info "使用 'bl --help' 查看所有命令"
                exit 1
            fi
            ;;
    esac
}

main "$@"
